A draft based on a draft? Pure madness.

This revamps the interface of interpretNew to the point it can cover almost all previous uses of interpretH. The only exception are the bad lower- interpreters, and if we really want, we can expand the interface to cover them too.

Despite its power, the interface is actually fairly simple: we manage to avoid exposing that MonadTransWeave is at play under the hood.

interpretNew has the type signature

interpretNew :: forall e r a
              . EffHandlerH e r
             -> Sem (e ': r) a
             -> Sem r a

where

type EffHandlerH e r = forall z t x. Traversable t => e z x -> Sem (RunH z t (e ': r) ': r) x

Which is only moderately scary. The interface associated with RunH are the functions:

-- Main function to run HO thunks
runH :: z a -> Sem (RunH z t (e ': r) ': r) a

-- Run a HO thunk, but don't automatically recursively run the current interpreter on it.
runH' :: z a -> Sem (e ': RunH z t (e ': r) ': r) a

-- Run a HO thunk and reify the local effectful state it results in
runExposeH :: z a -> Sem (RunH z t (e ': r) ': r) (t a)

-- The runH' equivalent of runExposeH
runExposeH' :: z a -> Sem (e ': RunH z t (e ': r) ': r) (t a)

-- Restore a reified effectful state
restoreH :: t a -> Sem (RunH z t (e ': r) ': r) a

runExposeH and restoreH is for all the effectful state manipulation some interpreters need to do in order to work correctly, such as runWriter.

Now the question is: is even this too complex? We can take measures to reduce the complexity: such as having Polysemy only export runH and runH', and having the other methods be part of a different module, say Polysemy.InterpretH or something, but the type of EffHandlerH is still somewhat scary -- on the same level as Tactical.

Unfortunately, I haven't found a way to simplify EffHandlerH further -- even if you try to only support runH and runH', I still can't figure out a way to get rid of the 2 extra type variables associated with RunH (although you can remove the Traversable constraint.)